// 引用 expess 框架
const express = require('express')

const app = express()

require('./connect.js') // 连接数据库
// mongoimport -d sjk -c user --file .\04user.json 导入的json 为对象形式
// mongoimport --db Ecommerce --collection ShouJis --jsonArray .\ShouJi.json  如果json 文件是 数组对象形式[{},{}]
// 商品的分类属性表
const { FenLei } = require('./admin.js')
// 购物车
const { Carts } = require('./admin.js')
// 一级导航对应的表
// 数据库中的 图书表 LevelOneId 为  0 或者 搜索关键字为"图书 音像 数字产品 书  文字  阅读"展示该表
const { TuShu } = require('./admin.js')
// 数据库中的 家用电器表 LevelOneId 为 1 或者 搜索关键字为"家用电器 电器 冰箱 电视 洗衣机 吹风机"展示该表
const { DianQi } = require('./admin.js')
// 数据库中的 手机表 LevelOneId为  2  或者 搜索关键字为"手机 数码 充值 小米 华为 苹果 IQOO ov oppo vivo 魅族"展示该表
const { ShouJi } = require('./admin.js')
// 数据库中的 办公电脑表 LevelOneId为  3 或者 搜索关键字为"办公电脑 办公 电脑 联想 外星人 笔记本 台式机  游戏机"展示该表
const { DianNao } = require('./admin.js')

// 二级导航对应的表
// 数据库中的 电子图书表 LevelTwoId 为 0 或者 搜索关键字为"电子书"展示该表
const { DianZiShu } = require('./admin.js')
// 数据库中的 音乐表 LevelTwoId 为 1 或者 搜索关键字为"音乐"展示该表
const { YinYue } = require('./admin.js')
// 数据库中的 电影表 LevelTwoId 为 2 或者 搜索关键字为"数字电影 电影"展示该表
const { DianYing } = require('./admin.js')

// 三级导航对应的表
// 数据库中的 小说表 LevelTwoId为 0 且LevelThreeId为 0 或者 搜索关键字为"小说"展示该表
const { XiaoShuo } = require('./admin.js')
// 数据库中的 流行音乐表 LevelTwoId为 1 且LevelThreeId为 0 或者 搜索关键字为"流行音乐"展示该表
const { LiuXing } = require('./admin.js')
// 数据库中的 影视表 LevelTwoId为 2 且LevelThreeId为 0 或者 搜索关键字为"电影"展示该表
const { YingShi } = require('./admin.js')
// FenLei.find().then((result) => console.log(result)) // 查询所有数据
// Carts.deleteMany({}).then((doc) => console.log(doc)) // 删除所有数据
/* YingShi.aggregate([{ $sample: { size: 2 } }]).then((result) => {  // 展示随机数据
  console.log(result)
}) */
// 查询并展示那张表的数据给 searchList api 中的 searchList.goodsList 数组
/* YingShi.find().then((result) => {
  // 将 表的数据 赋值给 searchList api 中的goodsList数组
  searchList.goodsList = result
  //   console.log(searchList.goodsList)
}) */

// ShouJi.find({ text: '华为手机' }).then((result) => console.log(result))

// home 首页 接口
const { NavigationMenu } = require('./home/NavigationMenu.js') // 三级导航菜单数据源  纯js数组，无数据库
// 三级导航菜单接口
app.get('/NavigationMenu', (req, res) => {
  res.send(NavigationMenu)
})

// search 搜索页面 接口
const { searchList } = require('./search/searchList.js') // 搜索页面数据源 从数据库中获取数据

app.post('/SearchList', (req, res) => {
  // 服务端接收 post 的请求参数
  let postData = ''
  req.on('data', (chunk) => {
    // 将 客户端的 传参 转为字符串
    postData += chunk.toString()
  })
  req.on('end', async () => {
    // 将客户端的请求参数转为 对象形式
    let GoodsList = JSON.parse(postData)
    console.log(GoodsList)

    // 搜索关键字
    // 展示图书表
    let tushu = ['书', '数字产品', '数字商品', '图书', '文字', '阅读']
    let VariableTushu = tushu.findIndex((item) => item == GoodsList.keyword) //查询数组是否存在该成员

    // 展示电器表
    let dianqi = [
      '家用电器',
      '家用',
      '电器',
      '冰箱',
      '电视',
      '洗衣机',
      '吹风机'
    ]
    let VariableDianqi = dianqi.findIndex((item) => item == GoodsList.keyword)

    // 展示手机表
    let shouji = [
      '手机',
      '数码',
      '充值',
      '小米',
      '小米手机',
      '华为',
      '华为手机',
      '苹果',
      '苹果手机',
      'IQOO',
      'ov',
      'oppo',
      'vivo',
      '魅族'
    ]
    let VariableShouji = shouji.findIndex((item) => item == GoodsList.keyword)

    // 展示 办公电脑表
    let diannao = [
      '办公电脑',
      '办公',
      '电脑',
      '联想',
      '外星人',
      '笔记本',
      '台式机',
      '游戏机'
    ]
    let VariableDianNao = diannao.findIndex((item) => item == GoodsList.keyword)

    // 展示电子书表
    let dianzishu = ['电子书']
    let VariableDianzishu = dianzishu.findIndex(
      (item) => item == GoodsList.keyword
    )
    // 展示音乐表
    let yinyue = ['音乐']
    let VariableYinyue = yinyue.findIndex((item) => item == GoodsList.keyword)

    // 展示影视表
    let yingshi = ['影视', '数字影视']
    let VariableYingshi = yingshi.findIndex((item) => item == GoodsList.keyword)

    // 展示小说表
    let xiaoshuo = ['小说']
    let VariableXiaoshuo = xiaoshuo.findIndex(
      (item) => item == GoodsList.keyword
    )

    // 展示流行音乐表
    let liuxing = ['流行音乐', '流行']
    let VariableLiuxing = liuxing.findIndex((item) => item == GoodsList.keyword)

    // 展示流行电影表表
    let dianying = ['电影']
    let VariableLDianying = dianying.findIndex(
      (item) => item == dianying.keyword
    )

    //  商品的分类属性
    // OneID 一级分类 商品分类 根据id不同展示不同的表数据
    // TwoID 二级分类  商品价格分类 对商品的价格进行分类
    let OneID = 0 // 当 OneID = 0时  有三种情况，
    //、、、、、、、  1. 切换商品分类导航 从 导航a 跳到 导航b  导航b没有写对应的表数据 此时会展示空数据 隐藏组件
    //               2. 切换商品分类导航 从 导航a 跳到 导航b  导航b有对应的表数据   此时默认展示表一级对应的表数据 二级不进行筛选
    //               3. 当搜索的关键字不存在时  服务端没有处理对应的query或params参数请求的数据 展示空数组
    //
    //              就是  SearchList.GoodsList 和 SearchList.Classification 商品数组和商品分类数组 这俩个

    let TwoID = -1 // 用来记录 商品分类的 id值 -1代表没有一个二级商品分类属性被选中
    try {
      OneID = GoodsList.info.OneID
    } catch (e) {
      // 如果不进行捕获 必定报错 因为 浏览器的请求参数不一定带 GoodsList.info 属性
      // 只有点击 商品分类查询时才会携带 GoodsList.info参数
      console.log('客户端没有发起商品分类请求')
    }
    try {
      TwoID = GoodsList.info.TwoID
    } catch (e) {
      // 如果不进行捕获 必定报错 因为 浏览器的请求参数不一定带 GoodsList.info 属性
      console.log('客户端没有发起商品分类请求')
    }

    // 记录是否点击了商品的筛选 排序
    let order = GoodsList.order // 排序俩种情况 升序 asc  降序 desc

    // 记录每一页商品查询多少条
    let pageSize = GoodsList.pageSize
    // 记录当前为第几页 默认为第 1 页
    let pages = GoodsList.pages
    // 数据分页展示
    let skipPages = pages * pageSize - pageSize // 跳过多少条数据
    console.log('跳过' + skipPages + '条数据')

    // console.log(OneID + '一级商品分类id')

    // 展示商品的信息 goodsList
    // 导航 和 关键字对应的表
    // 导航传参 query 关键字 params
    // 导航不携带 params 参数 携带 query参数 （query参数为对应导航）
    // 关键字  携带 params 和 query参数 （params 为搜索关键字）
    // 点击导航根据他们的 id 不同 返回相对应的 表
    //  LevelOneID 一级导航   LevelTwoID 二级导航    LevelThreeID 三级导航
    // Variable开头的都是查询搜索框关键字 查询是否在数组中存在 不返回-1 代表存在
    // searchList.goodsLis  search页面的商品信息数组
    // searchList.Classification search页面的商品分类属性

    // 服务端的携带参数
    /*  // 首页跳转中 三级联动 一级导航id
     LevelOneID: '',
     // 二级导航id
     LevelTwoID: '',
     // 三级导航id
     LevelThreeID: '',
     // 搜索框的关键字
     keyword: '',
     // 排序
     order: '',
     // 当前为第几页
     pages: '',
     // 配置每一页有多少条数据
     pageSize: '',
     // 商品分类的属性searchLis
     info: '阿道夫水水水水水水水水水水',
     // 这个是让服务端分清楚 true 为 搜索关键字 false为商品分类属性  目的是为了防止查询冲突
     state: true */

    // await 将 异步操作改为同步操作 从而实现 修改 返回浏览器的值
    if (GoodsList.LevelOneID == 0 || VariableTushu != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await TuShu.find().then(
        (result) => result.length
      )
      // 默认展示
      await TuShu.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 图书分类表
      await FenLei.find({ id: 0 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await TuShu.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await TuShu.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      // 0-100元
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await TuShu.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await TuShu.find({ price: { $gt: 0, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await TuShu.find({ price: { $gt: 0, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await TuShu.find({ price: { $gt: 0, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await TuShu.find({
          price: { $gt: 100, $lt: 150 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await TuShu.find({ price: { $gt: 100, $lt: 150 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await TuShu.find({ price: { $gt: 100, $lt: 150 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await TuShu.find({ price: { $gt: 100, $lt: 150 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await TuShu.find({
          price: { $gt: 150, $lt: 200 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await TuShu.find({ price: { $gt: 150, $lt: 200 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await TuShu.find({ price: { $gt: 150, $lt: 200 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await TuShu.find({ price: { $gt: 150, $lt: 200 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await TuShu.find({
          price: { $gt: 200 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await TuShu.find({ price: { $gt: 200 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await TuShu.find({ price: { $gt: 200 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await TuShu.find({ price: { $gt: 200 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (GoodsList.LevelOneID == 1 || VariableDianqi != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await DianQi.find().then(
        (result) => result.length
      )
      // 默认展示
      await DianQi.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 电器分类表
      await FenLei.find({ id: 1 }).then((result) => {
        searchList.Classification = result
      })
      if (order == 'asc') {
        await DianQi.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await DianQi.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 商品信息电器表
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianQi.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianQi.find({ price: { $gt: 0, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianQi.find({ price: { $gt: 0, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianQi.find({ price: { $gt: 0, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianQi.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianQi.find({ price: { $gt: 100, $lt: 150 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianQi.find({ price: { $gt: 100, $lt: 150 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianQi.find({ price: { $gt: 100, $lt: 150 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then(
              (result) => {
                searchList.goodsList = result
              }
            )
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianQi.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianQi.find({ price: { $gt: 150, $lt: 200 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianQi.find({ price: { $gt: 150, $lt: 200 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianQi.find({ price: { $gt: 150, $lt: 200 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then(
              (result) => {
                searchList.goodsList = result
              }
            )
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianQi.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianQi.find({ price: { $gt: 200 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianQi.find({ price: { $gt: 200 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianQi.find({ price: { $gt: 200 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (GoodsList.LevelOneID == 2 || VariableShouji != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await ShouJi.find().then(
        (result) => result.length
      )
      // 默认展示
      await ShouJi.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 手机分类表
      await FenLei.find({ id: 2 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await ShouJi.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await ShouJi.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }

      // GoodsList.state 俩种状态 true 搜索关键字检索  是  false 是 商品分类属性检索
      if (GoodsList.state == true) {
        if (GoodsList.keyword == '手机') {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find().then(
            (result) => result.length
          )
          // 默认展示
          await ShouJi.find()
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
          if (order == 'asc') {
            await ShouJi.find()
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find()
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }
        }
        if (GoodsList.keyword == '华为' || GoodsList.keyword == '华为手机') {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find({
            text: '华为手机'
          }).then((result) => result.length)
          // 默认展示
          await ShouJi.find({ text: '华为手机' })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
          if (order == 'asc') {
            await ShouJi.find({ text: '华为手机' })
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            console.log(2)
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find({ text: '华为手机' })
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }
        }
        if (GoodsList.keyword == '小米' || GoodsList.keyword == '小米手机') {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find({
            text: '小米手机'
          }).then((result) => result.length)
          // 默认展示
          await ShouJi.find({ text: '小米手机' })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
          if (order == 'asc') {
            await ShouJi.find({ text: '小米手机' })
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find({ text: '小米手机' })
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }
        }
        if (GoodsList.keyword == '苹果' || GoodsList.keyword == '苹果手机') {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find({
            text: '苹果手机'
          }).then((result) => result.length)
          // 默认展示
          await ShouJi.find({ text: '苹果手机' })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
          if (order == 'asc') {
            await ShouJi.find({ text: '苹果手机' })
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find({ text: '苹果手机' })
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }
        }
      } else if (GoodsList.state == false) {
        if (OneID == 0) {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find().then(
            (result) => result.length
          )
          // 排序
          if (order == 'asc') {
            await ShouJi.find()
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find()
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else {
            await ShouJi.find()
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }

          if (TwoID == 0) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              price: { $gt: 0, $lt: 3000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                price: { $gt: 0, $lt: 3000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 1) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              price: { $gt: 3000, $lt: 4500 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                price: { $gt: 3000, $lt: 4500 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 2) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              price: { $gt: 4500, $lt: 6000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                price: { $gt: 4500, $lt: 6000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 3) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              price: { $gt: 6000, $lt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                price: { $gt: 6000, $lt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 4) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              price: { $gt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                price: { $gt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                price: { $gt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                price: { $gt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          }
        }
        if (OneID == 1) {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find({
            text: '华为手机'
          }).then((result) => result.length)
          // 排序
          if (order == 'asc') {
            await ShouJi.find({ text: '华为手机' })
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find({ text: '华为手机' })
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else {
            await ShouJi.find({ text: '华为手机' })
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }

          if (TwoID == 0) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '华为手机',
              price: { $gt: 0, $lt: 3000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 1) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '华为手机',
              price: { $gt: 3000, $lt: 4500 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 2) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '华为手机',
              price: { $gt: 4500, $lt: 6000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 3) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '华为手机',
              price: { $gt: 6000, $lt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 4) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '华为手机',
              price: { $gt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '华为手机',
                price: { $gt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          }
        }
        if (OneID == 2) {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find({
            text: '小米手机'
          }).then((result) => result.length)
          // 排序
          if (order == 'asc') {
            await ShouJi.find({ text: '小米手机' })
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find({ text: '小米手机' })
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else {
            await ShouJi.find({ text: '小米手机' })
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }

          if (TwoID == 0) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '小米手机',
              price: { $gt: 0, $lt: 3000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 1) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '小米手机',
              price: { $gt: 3000, $lt: 4500 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 2) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '小米手机',
              price: { $gt: 4500, $lt: 6000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 3) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '小米手机',
              price: { $gt: 6000, $lt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 4) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '小米手机',
              price: { $gt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '小米手机',
                price: { $gt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          }
        }
        if (OneID == 3) {
          // 查询 对应的表有多少条数据
          searchList.DataQuantity = await ShouJi.find({
            text: '苹果手机'
          }).then((result) => result.length)

          // 排序
          if (order == 'asc') {
            await ShouJi.find({ text: '苹果手机' })
              .sort('price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else if (order == 'desc') {
            // console.log(GoodsList.info.val) //输出一下商品价格
            await ShouJi.find({ text: '苹果手机' })
              .sort('-price')
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          } else {
            await ShouJi.find({ text: '苹果手机' })
              .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
              .limit(pageSize) // 每一次查询多少条数据 默认为 5
              .then((result) => {
                // 将 表的数据 赋值给 searchList api 中的goodsList数组
                searchList.goodsList = result
              })
          }
          if (TwoID == 0) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '苹果手机',
              price: { $gt: 0, $lt: 3000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 0, $lt: 3000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 1) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '苹果手机',
              price: { $gt: 3000, $lt: 4500 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 3000, $lt: 4500 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 2) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '苹果手机',
              price: { $gt: 4500, $lt: 6000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 4500, $lt: 6000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 3) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '苹果手机',
              price: { $gt: 6000, $lt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 6000, $lt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          } else if (TwoID == 4) {
            // 查询 对应的表有多少条数据
            searchList.DataQuantity = await ShouJi.find({
              text: '苹果手机',
              price: { $gt: 8000 }
            }).then((result) => result.length)
            // 排序
            if (order == 'asc') {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 8000 }
              })
                .sort('price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else if (order == 'desc') {
              // console.log(GoodsList.info.val) //输出一下商品价格
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 8000 }
              })
                .sort('-price')
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  // 将 表的数据 赋值给 searchList api 中的goodsList数组
                  searchList.goodsList = result
                })
            } else {
              await ShouJi.find({
                text: '苹果手机',
                price: { $gt: 8000 }
              })
                .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
                .limit(pageSize) // 每一次查询多少条数据 默认为 5
                .then((result) => {
                  searchList.goodsList = result
                })
            }
          }
        }
      }
    } else if (GoodsList.LevelOneID == 3 || VariableDianNao != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await DianNao.find().then(
        (result) => result.length
      )
      // 默认展示
      await DianNao.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 电脑分类表
      await FenLei.find({ id: 3 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await DianNao.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await DianNao.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianNao.find({
          price: { $gt: 0, $lt: 3000 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianNao.find({ price: { $gt: 0, $lt: 3000 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianNao.find({ price: { $gt: 0, $lt: 3000 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianNao.find({ price: { $gt: 0, $lt: 3000 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianNao.find({
          price: { $gt: 3000, $lt: 6000 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianNao.find({ price: { $gt: 3000, $lt: 6000 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianNao.find({ price: { $gt: 3000, $lt: 6000 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianNao.find({ price: { $gt: 3000, $lt: 6000 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianNao.find({
          price: { $gt: 6000 }
        }).then((result) => result.length)
        if (order == 'asc') {
          await DianNao.find({ price: { $gt: 6000 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianNao.find({ price: { $gt: 6000 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianNao.find({ price: { $gt: 6000 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (GoodsList.LevelTwoID == 0 || VariableDianzishu != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await DianZiShu.find().then(
        (result) => result.length
      )
      // 默认展示
      await DianZiShu.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 电子书分类表
      await FenLei.find({ id: 4 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await DianZiShu.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await DianZiShu.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      // 0-100元
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianZiShu.find({
          price: { $gt: 0, $lt: 20 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianZiShu.find({ price: { $gt: 0, $lt: 20 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianZiShu.find({ price: { $gt: 0, $lt: 20 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianZiShu.find({ price: { $gt: 0, $lt: 20 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianZiShu.find({
          price: { $gt: 20, $lt: 50 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianZiShu.find({ price: { $gt: 20, $lt: 50 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianZiShu.find({ price: { $gt: 20, $lt: 50 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianZiShu.find({ price: { $gt: 20, $lt: 50 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianZiShu.find({
          price: { $gt: 50, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianZiShu.find({ price: { $gt: 50, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          await DianZiShu.find({ price: { $gt: 50, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else {
          await DianZiShu.find({ price: { $gt: 50, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianZiShu.find({
          price: { $gt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianZiShu.find({ price: { $gt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianZiShu.find({ price: { $gt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianZiShu.find({ price: { $gt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (GoodsList.LevelTwoID == 1 || VariableYinyue != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await YinYue.find().then(
        (result) => result.length
      )
      // 默认展示
      await YinYue.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 音乐分类表
      await FenLei.find({ id: 5 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await YinYue.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await YinYue.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YinYue.find({
          price: { $gt: 0, $lt: 20 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await YinYue.find({ price: { $gt: 0, $lt: 20 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await YinYue.find({ price: { $gt: 0, $lt: 20 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await YinYue.find({ price: { $gt: 0, $lt: 20 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YinYue.find({
          price: { $gt: 20, $lt: 50 }
        }).then((result) => result.length)
        if (order == 'asc') {
          await YinYue.find({ price: { $gt: 20, $lt: 50 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await YinYue.find({ price: { $gt: 20, $lt: 50 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await YinYue.find({ price: { $gt: 20, $lt: 50 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YinYue.find({
          price: { $gt: 50, $lt: 100 }
        }).then((result) => result.length)
        if (order == 'asc') {
          await YinYue.find({ price: { $gt: 50, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          await YinYue.find({ price: { $gt: 50, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else {
          await YinYue.find({ price: { $gt: 50, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YinYue.find({
          price: { $gt: 100 }
        }).then((result) => result.length)
        if (order == 'asc') {
          await YinYue.find({ price: { $gt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await YinYue.find({ price: { $gt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await YinYue.find({ price: { $gt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (GoodsList.LevelTwoID == 2 || VariableYingshi != -1) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await DianYing.find().then(
        (result) => result.length
      )
      // 默认展示
      await DianYing.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 影视分类表
      await FenLei.find({ id: 6 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await DianYing.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await DianYing.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianYing.find({
          price: { $gt: 0, $lt: 20 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianYing.find({ price: { $gt: 0, $lt: 20 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianYing.find({ price: { $gt: 0, $lt: 20 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianYing.find({ price: { $gt: 0, $lt: 20 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianYing.find({
          price: { $gt: 20, $lt: 50 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianYing.find({ price: { $gt: 20, $lt: 50 } })
            .sort('price')
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianYing.find({ price: { $gt: 20, $lt: 50 } })
            .sort('-price')
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianYing.find({ price: { $gt: 20, $lt: 50 } }).then(
            (result) => {
              searchList.goodsList = result
            }
          )
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianYing.find({
          price: { $gt: 50, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianYing.find({ price: { $gt: 50, $lt: 100 } })
            .sort('price')
            .then((result) => {
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          await DianYing.find({ price: { $gt: 50, $lt: 100 } })
            .sort('-price')
            .then((result) => {
              searchList.goodsList = result
            })
        } else {
          await DianYing.find({ price: { $gt: 50, $lt: 100 } }).then(
            (result) => {
              searchList.goodsList = result
            }
          )
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await DianYing.find({
          price: { $gt: 150 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await DianYing.find({ price: { $gt: 100 } })
            .sort('price')
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await DianYing.find({ price: { $gt: 100 } })
            .sort('-price')
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await DianYing.find({ price: { $gt: 100 } }).then((result) => {
            searchList.goodsList = result
          })
        }
      }
    } else if (
      (GoodsList.LevelThreeID == 0 && GoodsList.NavigationName == '小说') ||
      VariableXiaoshuo != -1
    ) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await XiaoShuo.find().then(
        (result) => result.length
      )
      // 默认展示
      await XiaoShuo.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 小说分类表
      await FenLei.find({ id: 7 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await XiaoShuo.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await XiaoShuo.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await XiaoShuo.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await XiaoShuo.find({ price: { $gt: 0, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await XiaoShuo.find({ price: { $gt: 0, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await XiaoShuo.find({ price: { $gt: 0, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await XiaoShuo.find({
          price: { $gt: 100, $lt: 150 }
        }).then((result) => result.length)
        if (order == 'asc') {
          await XiaoShuo.find({ price: { $gt: 100, $lt: 500 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await XiaoShuo.find({ price: { $gt: 100, $lt: 500 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await XiaoShuo.find({ price: { $gt: 100, $lt: 500 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await XiaoShuo.find({
          price: { $gt: 500, $lt: 1000 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await XiaoShuo.find({ price: { $gt: 500, $lt: 1000 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          await XiaoShuo.find({ price: { $gt: 500, $lt: 1000 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else {
          await XiaoShuo.find({ price: { $gt: 500, $lt: 1000 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await XiaoShuo.find({
          price: { $gt: 1000 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await XiaoShuo.find({ price: { $gt: 1000 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await XiaoShuo.find({ price: { $gt: 1000 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await XiaoShuo.find({ price: { $gt: 1000 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (
      (GoodsList.LevelThreeID == 0 && GoodsList.NavigationName == '流行音乐') ||
      VariableLiuxing != -1
    ) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await LiuXing.find().then(
        (result) => result.length
      )
      // 默认展示
      await LiuXing.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 流行音乐分类表
      await FenLei.find({ id: 8 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await LiuXing.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await LiuXing.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      if (TwoID == 0) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await LiuXing.find({
          price: { $gt: 0, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await LiuXing.find({ price: { $gt: 0, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await LiuXing.find({ price: { $gt: 0, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await LiuXing.find({ price: { $gt: 0, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await LiuXing.find({
          price: { $gt: 100, $lt: 200 }
        }).then((result) => result.length)
        if (order == 'asc') {
          await LiuXing.find({ price: { $gt: 100, $lt: 200 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await LiuXing.find({ price: { $gt: 100, $lt: 200 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await LiuXing.find({ price: { $gt: 100, $lt: 200 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await LiuXing.find({
          price: { $gt: 200, $lt: 300 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await LiuXing.find({ price: { $gt: 200, $lt: 300 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          await LiuXing.find({ price: { $gt: 200, $lt: 300 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else {
          await LiuXing.find({ price: { $gt: 200, $lt: 300 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await LiuXing.find({
          price: { $gt: 300 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await LiuXing.find({ price: { $gt: 300 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await LiuXing.find({ price: { $gt: 300 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await LiuXing.find({ price: { $gt: 300 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else if (
      (GoodsList.LevelThreeID == 0 && GoodsList.NavigationName == '电影') ||
      VariableLDianying != -1
    ) {
      // 查询 对应的表有多少条数据
      searchList.DataQuantity = await YingShi.find().then(
        (result) => result.length
      )
      // 默认展示
      await YingShi.find()
        .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
        .limit(pageSize) // 每一次查询多少条数据 默认为 5
        .then((result) => {
          // 将 表的数据 赋值给 searchList api 中的goodsList数组
          searchList.goodsList = result
        })
      // 电影分类表
      await FenLei.find({ id: 9 }).then((result) => {
        searchList.Classification = result
      })
      // 排序
      if (order == 'asc') {
        await YingShi.find()
          .sort('price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      } else if (order == 'desc') {
        // console.log(GoodsList.info.val) //输出一下商品价格
        await YingShi.find()
          .sort('-price')
          .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
          .limit(pageSize) // 每一次查询多少条数据 默认为 5
          .then((result) => {
            // 将 表的数据 赋值给 searchList api 中的goodsList数组
            searchList.goodsList = result
          })
      }
      // 对商品的价格查询
      if (TwoID == 0) {
        // 排序
        if (order == 'asc') {
          await YingShi.find({ price: { $gt: 0, $lt: 50 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await YingShi.find({ price: { $gt: 0, $lt: 50 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await YingShi.find({ price: { $gt: 0, $lt: 50 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 1) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YingShi.find({
          price: { $gt: 50, $lt: 100 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await YingShi.find({ price: { $gt: 50, $lt: 100 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await YingShi.find({ price: { $gt: 50, $lt: 100 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await YingShi.find({ price: { $gt: 50, $lt: 100 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 2) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YingShi.find({
          price: { $gt: 100, $lt: 150 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await YingShi.find({ price: { $gt: 100, $lt: 150 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          await YingShi.find({ price: { $gt: 100, $lt: 150 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        } else {
          await YingShi.find({ price: { $gt: 100, $lt: 150 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      } else if (TwoID == 3) {
        // 查询 对应的表有多少条数据
        searchList.DataQuantity = await YingShi.find({
          price: { $gt: 150 }
        }).then((result) => result.length)
        // 排序
        if (order == 'asc') {
          await YingShi.find({ price: { $gt: 150 } })
            .sort('price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else if (order == 'desc') {
          // console.log(GoodsList.info.val) //输出一下商品价格
          await YingShi.find({ price: { $gt: 150 } })
            .sort('-price')
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              // 将 表的数据 赋值给 searchList api 中的goodsList数组
              searchList.goodsList = result
            })
        } else {
          await YingShi.find({ price: { $gt: 150 } })
            .skip(skipPages) // 跳过多少条  默认为 0  第2页跳过5条 第3页跳过10条
            .limit(pageSize) // 每一次查询多少条数据 默认为 5
            .then((result) => {
              searchList.goodsList = result
            })
        }
      }
    } else {
      searchList.goodsList = []
      searchList.Classification = []
    }

    res.send({ status: 200, msg: '成功', data: searchList })
  })
})
// Carts.deleteMany({}).then((doc) => console.log(doc)) // 删除所有数据
// 商品详情  接口
app.post('/detail', (req, res) => {
  // 服务端接收 post 的请求参数
  let postData = ''

  req.on('data', (chunk) => {
    postData += chunk.toString()
  })
  req.on('end', async () => {

    // 将 字符串装为对象
    let register = JSON.parse(postData)

    console.log(register);


    // 购物车这里的逻辑有点复杂 不单单靠商品的id判断，还要判断筛选属性 主要是参考京东
    // 1. id不存在  商品不存在，添加新的商品
    // 2. id存在  判断该商品是否选了一样的属性 比如 用户选择 id 0 颜色：红色  版本 ：移动  数据库中 id 0 颜色：红色  版本 ：移动 
    //    判断结果一致 返回 ture 此时 如果需要更新 商品数量
    // 3 id存在  判断该商品是否选了一样的属性 比如 用户选择 id 0 颜色：红色  版本 ：移动  数据库中 id 0 颜色：黑色  版本 ：电信
    //   判断结果不一致 需要添加 新的商品 

    let GooodsID = register.goodsID
    // 当前购买的商品 在购物车数据库中已经存在多少件,没有这件商品返回空，不影响
    let presentGoodsCount = await Carts.find({ goodsID: GooodsID }).select('goodsCount -_id')
    // 将 presentGoodsCount 查询的对象转换为具体的数字
    // 如果商品id和商品筛选属性一致 添加该商品数量
    let str = presentGoodsCount.toString()
    let index = str.lastIndexOf(":")
    str = str.substring(index + 1, str.length - 1);
    let count = Number(str)
    // Carts.find().then((result) => console.log(result))
    // count 数据库中商品数量  register.goodsCount 新添加的商品数量
    let addCount = count + register.goodsCount


    // 如果该商品已经在数据中存在，还添加，就把数量 提一下
    // 如果当前商品不存在购物车 添加上去
    Carts.find()
      .select('goodsID -_id')
      .then((result) => {

        // 根据ID检索当前购买商品是否在数据库中存在
        const There = result.findIndex((item) => item.goodsID == GooodsID)

        // 当前商品存在数据库
        if (There != -1) {
          Carts.find({ goodsID: register.goodsID })
            .select('goodsFiltering -_id')
            .then((result) => {
              // 如果当前 商品存在数据中 但他们的筛选数据不同
              // false id存在，但对应的筛选属性不一样
              // true  id存在 ，对应的筛选属性也一样
              let filteringThere = false;
              result.forEach((item) => {
                if (JSON.stringify(item.goodsFiltering) == JSON.stringify(register.filtering)) {
                  filteringThere = true
                }
              })
              if (filteringThere == false) {
                // 添加新的商品
                Carts.create({
                  goodsID: register.goodsID,
                  token: register.token,
                  goodsCount: register.goodsCount,
                  title: register.title,
                  price: register.price,
                  comments: register.comments,
                  goodsImg: register.goodsImg,
                  goodsFiltering: register.filtering,
                  stateCheck: '1'
                })
                  .then(() => {
                    console.log('加入购物车成功')
                  })
                  .catch(() => {
                    console.log('加入购物车失败')
                  })
              } else {
                // 更新商品数量
                Carts.find({ goodsID: GooodsID, goodsFiltering: register.filtering }).updateOne({ presentGoodsCount }, { goodsCount: addCount }).then((e) =>
                  console.log(e)
                )
              }
            })
        } else {
          // 数据库中不存在该id商品
          Carts.create({
            goodsID: register.goodsID,
            token: register.token,
            goodsCount: register.goodsCount,
            title: register.title,
            price: register.price,
            comments: register.comments,
            goodsImg: register.goodsImg,
            goodsFiltering: register.filtering,
            stateCheck: '1'
          })
            .then(() => {
              console.log('加入购物车成功')
            })
            .catch(() => {
              console.log('加入购物车失败')
            })
        }
      })
    res.send({ status: 200, data: 'ok' })
  })
})

// 购物车接口
app.post('/carts', (req, res) => {
  // 服务端接收 post 的请求参数
  let postData = ''

  req.on('data', (chunk) => {
    postData += chunk.toString()
  })
  req.on('end', async () => {

    // 将 字符串装为对象
    let register = JSON.parse(postData)

    console.log(register);

    // 处理商品的数量 + - 或者直接修改
    let state = register.state.event  // 判断 + - input
    let count = register.state.count
    // 查询数据库中的商品数量
    let presentGoodsCount = 0;
    // 查询数据库中商品的状态
    let stateCheck = 0;
    try {
      if (register._id != '') {
        presentGoodsCount = await Carts.find({ _id: register._id }).select('goodsCount -_id')
        stateCheck = await Carts.find({ _id: register._id }).select('stateCheck -_id')
      }
    } catch {
    }

    // 将查询的商品数量结果 转换为具体的数字  
    let str = presentGoodsCount.toString()
    let index = str.lastIndexOf(":")
    str = str.substring(index + 1, str.length - 1)
    let goodsCount = Number(str)
    // 查询状态,然后转换
    let str2 = stateCheck.toString()
    let index2 = str2.lastIndexOf(":")
    str2 = str2.substring(index2 + 3, str2.length - 3)
    stateCheck = str2
    console.log(str2)


    // 返回最终修改后的商品数量
    let add, sub;
    switch (state) {
      case 'input':
        if (count < 1) count = 1
      case 'add':
        add = goodsCount + 1
        break
      case 'sub':
        sub = goodsCount - 1
        if (sub < 1) sub = 1
        break
    }
    // 产品数量的修改
    switch (state) {
      case 'input':
        Carts.find({ _id: register._id }).updateOne({ goodsCount: goodsCount }, { goodsCount: count }).then((result) => console.log(result))
      case 'add':
        Carts.find({ _id: register._id }).updateOne({ goodsCount: goodsCount }, { goodsCount: add }).then((result) => console.log(result))
        break
      case 'sub':
        Carts.find({ _id: register._id }).updateOne({ goodsCount: goodsCount }, { goodsCount: sub }).then((result) => console.log(result))
        break
    }

    // 产品状态的修改
    if (register.Who == 'all') { // 全选
      Carts.updateMany({ stateCheck: '-1' }, { stateCheck: '1' }).then((result) => console.log(result))
    } else if (register.Who == 'noAll') { // 全不选
      Carts.updateMany({ stateCheck: '1' }, { stateCheck: '-1' }).then((result) => console.log(result))
    } else if (register.Who == 'single') { // 单个商品
      Carts.find({ _id: register._id }).updateOne({ stateCheck: stateCheck }, { stateCheck: register.stateCheck }).then((result) => console.log(result))

    }

    console.log(register);

    // 删除单个商品
    if (register.delete == 'DeleteGoods') {
      Carts.findOneAndDelete({ _id: register._id }).then((result) => console.log(result))
    }

    // 删除被选中的商品
    if (register.ScreeningDelete != '') {
      for (let i = 0; i < register.ScreeningDelete.length; i++) {
        register.ScreeningDelete.forEach(item => {
          Carts.findOneAndDelete({ _id: item }).then((result) => console.log(result))
        })
      }
    }


    let cartList = await Carts.find(register.token)
    res.send({ status: 200, data: cartList })
  })
})

// 监听端口
app.listen(3000, () => {
  console.log('服务器已经启动,3000端口监听中...http://localhost:3000')
})
